home *** CD-ROM | disk | FTP | other *** search
/ Floppyshop 2 / Floppyshop - 2.zip / Floppyshop - 2.iso / art&graf.ix / art-4635 / surf3d / surf3d3.c < prev    next >
C/C++ Source or Header  |  1993-12-06  |  17KB  |  726 lines
  1. #include <stdio.h>
  2. #include <tos.h>
  3. #include <ext.h>
  4. #include <math.h>
  5. #include <graphgem.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include "surf3d3.h"
  9.  
  10. int intersect(int x1,int y1,int w1,int h1,int x2,int y2,int w2,int h2);
  11. void sys_redraw(void);
  12. void mn_selected(void);
  13. void wm_redraw(void);
  14. void wm_topped(void);
  15. void wm_closed(void);
  16. void wm_fulled(void);
  17. void wm_arrowed(void);
  18. void wm_hslide(void);
  19. void wm_vslide(void);
  20. void wm_sized(void);
  21. void wm_moved(void);
  22. void show_dialog(OBJECT *arbre);
  23. void show_acqui(void);
  24. void show_angle(void);
  25.  
  26. struct window win;
  27.  
  28. int message[8];
  29. char eq[60]={"exp(-3*x*x)*exp(-3*y*y)-.3"};
  30.  
  31. /*  variables---------------------------------------------*/
  32. double x,y,z,oldX,oldY,newX,newY,incr,cosH,sinH,cosR,sinR;
  33. int H=30,R=30,haut,larg,depx,depy;
  34. int coulr,n;
  35. double * tablX,* tablY,* p1,* p2;
  36. int * tablC,* p3,cas=Z1,cas2=PAL1,axes=1;
  37. OBJECT *adr_menu,*adr_info,*adr_acqui,*adr_angle;
  38. short no_redraw=0;
  39.  
  40. /*  variables propres à "eval()"  */
  41. short j;
  42. char c;
  43. char chaine[30];
  44.  
  45.  
  46. /*  fonctions "eval()"  */
  47. double eval1(short,short);
  48. double eval2(short,short);
  49. double eval3(short,short);
  50.  
  51. /*  "eval1()": évalue une (sous-)fonction  */
  52. double eval1(short d,short f)
  53. {
  54.   double loc=0;  /*  résultat local  */
  55.   short i,i_prec;
  56.  
  57.   i=d;
  58.   while(i<f+2)
  59.   {
  60.     /*  découpe la fonction en somme de termes  */
  61.     j=0;  /*  compte les "()"  */
  62.     i_prec=i;
  63.     do  /*  recherche '+' ou '-'  */
  64.     {
  65.       c=eq[i++];
  66.       j+=(c=='(')-(c==')');
  67.     }
  68.     while(j || (c!='+' && c!='-' && i<=f));
  69.     if(i>f) i++;
  70.  
  71.     /*  évalue le terme  */
  72.     if(eq[i_prec-1]=='+' || i_prec==d) loc+=eval2(i_prec,i-2);
  73.     if(eq[i_prec-1]=='-') loc-=eval2(i_prec,i-2);
  74.   }
  75.   return loc;
  76. }
  77.  
  78. /*  "eval2()": évalue un produit ou une division  */
  79. double eval2(short d,short f)
  80. {
  81.   double loc=1;
  82.   short i,i_prec;
  83.  
  84.   i=d;
  85.   while(i<f+2)
  86.   {
  87.     /*  découpe la fonction en produit de termes  */
  88.     j=0;  /*  compte les "()"  */
  89.     i_prec=i;
  90.     do  /*  recherche '*' ou '/'  */
  91.     {
  92.       c=eq[i++];
  93.       j+=(c=='(')-(c==')');
  94.     }
  95.     while(j || (c!='*' && c!='/' && i<=f));
  96.     if(i>f) i++;
  97.  
  98.     /*  évalue le terme  */
  99.     if(eq[i_prec-1]=='*' || i_prec==d) loc*=eval3(i_prec,i-2);
  100.     if(eq[i_prec-1]=='/') loc/=eval3(i_prec,i-2);
  101.   }
  102.   return loc;
  103. }
  104.  
  105. /*  "eval3()": évalue un terme qui peut etre soit une fonction math., soit
  106. une variable simple, soit une constante, soit une fonction entre "()"  */
  107. double eval3(short d,short f)
  108. {
  109.   double loc=1,loc2=1;
  110.   int k,k_prec;
  111.  
  112.   if(eq[d]=='(')
  113.   { /*  cas de la fonction entre "()"  */
  114.     return eval1(d+1,f-1);
  115.   }
  116.  
  117.   if(d==f && eq[d]>'e')
  118.   { /*  cas de la variable simple  */
  119.     c=eq[d];
  120.     if(c=='x') return x; else return y;
  121.   }
  122.  
  123.   for(k=d;eq[k]!='(' && k<=f;k++);  /*  recherche '('  */
  124.  
  125.   if(k>f)
  126.   { /*  cas d'une constante  */
  127.     strncpy(chaine,&eq[d],f-d+1);
  128.     chaine[f-d+1]=0;
  129.     return atof(chaine);
  130.   }
  131.   else
  132.   { /*  cas d'une fonction math.  */
  133.     k_prec=k;
  134.  
  135.     for(j=0;;)  /*  recherche ',' ou ')'  */
  136.     {
  137.       c=eq[++k];
  138.       if(c==',' && j==0) break;
  139.       if(c=='(') {  j++;  continue;  }
  140.       if(c!=')') continue;
  141.       if(j) {  j--;  continue;  } else break;
  142.     }
  143.  
  144.     if(c==',')
  145.     { /*  évalue le 2ème paramètre  */
  146.       loc2=eval1(k+1,f-1);
  147.     }
  148.  
  149.     loc=eval1(k_prec+1,k-1);  /*  évalue le 1er paramètre  */
  150.     
  151.     /*  détermine de quelle fonction math il s'agit  */
  152.     switch(eq[d])
  153.     {
  154.     case 'a':
  155.       if(eq[d+1]=='b') return fabs(loc);  /*  abs()   */
  156.       else                                /*  angle(,)*/
  157.       return fabs(loc)<.0001? (loc2>0? M_PI_2:-M_PI_2)
  158.                             : atan(loc2/loc)+(loc<0? M_PI:0);
  159.     case 'c': return cos(loc);            /*  cos()   */
  160.     case 'e': return exp(loc);            /*  exp()   */
  161.     case 'h': return sqrt(loc*loc+loc2*loc2);  /*  hyp(,)  */
  162.     case 'i':
  163.       if(eq[d+1]=='n') return floor(loc); /*  int()   */
  164.       else return trunc(loc);             /*  ipart() */
  165.     case 'l': return log(loc);            /*  log()   */
  166.     case 'm': return fmod(loc,loc2);      /*  mod(,)  */
  167.     case 'p':
  168.       if(eq[d+2]=='w') return pow(loc,trunc(loc2));  /*  pow(,)  */
  169.       else return loc>0? loc:0;           /*  pos()   */
  170.     case 's':
  171.       switch(eq[d+1])
  172.       {
  173.       case 'i': return sin(loc);          /*  sin()   */
  174.       case 'q': return sqrt(loc);         /*  sqr()   */
  175.       default : return loc>0? 1:-1;       /*  sgn()   */
  176.       }
  177.     case 't': return tan(loc);            /*  tan()   */
  178.     case '=': return fabs(loc-loc2)<.0001;/*  =(,)    */
  179.     case '>': return loc>loc2;            /*  >(,)    */
  180.     default : return loc<loc2;            /*  <(,)    */
  181.     }
  182.   }
  183. }
  184.  
  185.  
  186. /*  fonctions---------------------------------------------*/
  187. double f(double x,double y)
  188. {
  189.     switch(cas)
  190.     {
  191.       case Z1 :
  192.         return(x*x*y*y-.3);
  193.       case Z2 :
  194.         return(x*x*x*y*y*y);
  195.       case Z3 :
  196.         return(cos(16*sqrt(x*x+y*y))/8);
  197.       case Z4 :
  198.         return(cos(5*x)*cos(5*y)/6);
  199.       case Z5 :
  200.         return(y*sqrt(fabs(x))*(x>0? 1:-1)/1.5);
  201.       case Z6 :
  202.         return((y<0 && y+incr>0)*x/2);
  203.       case Z7 :
  204.         return(sqrt(fabs(1-x*x-y*y))*(x*x+y*y<=1));
  205.       case Z8 :
  206.         return((y<0 && y+incr>0)*x/3+(x<0 && x+incr>0)*y/3);
  207.       case Z9 :
  208.         return(0.2-y*y*sqrt(fabs(4*x))/3);
  209.       case Z10 :
  210.         return(x*y*y*y);
  211.     default :
  212.       return(eval1(0,strlen(eq)-1));
  213.   }
  214. }
  215.  
  216. int X(void)
  217. {
  218.   return(depx+larg/2+240*(x*sinR+y*cosR)*larg/640);
  219. }
  220.  
  221. int Y(void)
  222. {
  223.   return(depy+haut/2-290*(z*cosH+sinH*(-x*cosR+y*sinR))*haut/480);
  224. }
  225.  
  226. void couleur(void)
  227. {
  228.   coulr=cas2==PAL1? (fabs(z)<1? (z>=0? 107+z*21:107+z*27)
  229.                               : (z>0? 127:80) )
  230.                   : (fabs(z)<1? (z>=0? 68+sqrt(z)*15:55-sqrt(-z)*16)
  231.                               : (z>0? 82:40) );
  232. }
  233.  
  234.  
  235. void wm_redraw(void)
  236. {
  237.   int i,j,X0,Y0;
  238.  
  239.   wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  240.   n=(larg>haut? larg:haut)/20+1;   /*  nombre de lignes de coté  */
  241.   incr=2/(double)(n-1);
  242.   cosR=cos(R*M_PI/180);
  243.   sinR=sin(R*M_PI/180);
  244.   cosH=cos(H*M_PI/180);
  245.   sinH=sin(H*M_PI/180);
  246.  
  247.   /*  alloue 3 tableaux pour mémoriser X, Y, et la couleur  */
  248.   i=n*n;
  249.   if((tablX=(double *)malloc(i*sizeof(double)))==0) return;
  250.   if((tablY=(double *)malloc(i*sizeof(double)))==0) return;
  251.   if((tablC=(int *)malloc(i*sizeof(int)))==0) return;
  252.  
  253.     pbox(depx,depy,depx+larg-1,depy+haut-1,0);  /*  cls  */
  254.  
  255.   if(axes)
  256.   { /*  tracé des axes  */
  257.     x=0;  /*  point O(0,0,0)  */
  258.     y=0;
  259.     z=0;
  260.     X0=X();
  261.     Y0=Y();
  262.   
  263.     x=1;  /*  axe x  */
  264.     y=0;
  265.     z=0;
  266.     line(X0,Y0,X(),Y(),4);
  267.     text_color(12);
  268.     text_type(GRAS);
  269.     outtextxy(X(),Y(),"x");
  270.  
  271.     x=0;  /*  axe y  */
  272.     y=1;
  273.     z=0;
  274.     line(X0,Y0,X(),Y(),4);
  275.     outtextxy(X(),Y(),"y");
  276.  
  277.     x=0;  /*  axe z  */
  278.     y=0;
  279.     z=1;
  280.     line(X0,Y0,X(),Y(),4);
  281.     outtextxy(X(),Y(),"z");
  282.   }
  283.  
  284.   /*  trace dans un 1er sens en mémorisant les valeurs  */
  285.   p1=tablX;
  286.   p2=tablY;
  287.   p3=tablC;
  288.   for(x=-1;x<1.001;x+=incr)
  289.   {
  290.     y=-1;
  291.     z=f(x,y);
  292.     couleur();
  293.     *(p3++)=coulr;
  294.     oldX=X();
  295.     oldY=Y();
  296.     *(p1++)=oldX;
  297.     *(p2++)=oldY;
  298.  
  299.     for(y+=incr;y<1.001;y+=incr)
  300.     {
  301.       z=f(x,y);
  302.       newX=X();
  303.       newY=Y();
  304.       couleur();
  305.       *(p3++)=coulr;
  306.       line(oldX,oldY,newX,newY,coulr);
  307.       oldX=newX;
  308.       oldY=newY;
  309.  
  310.       *(p1++)=newX;
  311.       *(p2++)=newY;
  312.     }
  313.   }
  314.  
  315.   /*  trace dans un 2ème sens en rappellant les valeurs  */
  316.   for(i=0;i<n;i++)
  317.   {
  318.     p1=tablX+i;
  319.     p2=tablY+i;
  320.     p3=tablC+i;
  321.  
  322.     oldX=*p1;
  323.     oldY=*p2;
  324.  
  325.     for(j=1;j<n;j++)
  326.     {
  327.       p1+=n;
  328.       p2+=n;
  329.       newX=*p1;
  330.       newY=*p2;
  331.  
  332.       line(oldX,oldY,newX,newY,*p3);
  333.       p3+=n;
  334.       oldX=newX;
  335.       oldY=newY;
  336.     }
  337.   }
  338.  
  339.  
  340.   free(tablX);
  341.   free(tablY);
  342.   free(tablC);
  343. }
  344.  
  345.  
  346. void main()
  347. {
  348.      char temp[100];
  349.      TEDINFO *ted;
  350.  
  351.    /*****   Initilisation de la station de travail   *****/
  352.    if(init_gem()!=1)
  353.    {
  354.       form_alert(1,"[3][ Impossible d'ouvrir | la station de travail ][Dommage!]");
  355.       exit(0);
  356.    }
  357.    /*****   Initialisation de ou des fenètre(s)   *****/
  358.    defmouse(0);
  359.    if(rsrc_load("surf3d3.rsc")==0)
  360.    {
  361.        form_alert(1,"[3][Impossible d'ouvrir | le fichier RSC][Dommage!]");
  362.        exit(0);
  363.    }
  364.    rsrc_gaddr(0,MENU,&adr_menu);
  365.    rsrc_gaddr(0,ACQUI,&adr_acqui);
  366.    ted=(TEDINFO *)adr_acqui[ACQUIEDI].ob_spec.tedinfo;
  367.      strcpy(ted->te_ptext,eq);/* recopi de la chaine dan tableau*/
  368.  
  369.    menu_bar(adr_menu,1);
  370.    win.fullx=param_gem.ecran_l;
  371.    win.fully=param_gem.ecran_h;
  372.    win.handle=wind_create(CLOSER | MOVER | NAME | SIZER |FULLER,20,20,win.fullx,win.fully);
  373.    if(win.handle<0)
  374.    {
  375.       form_alert(1,"[3][ Impossible d'ouvrir | la fenetre de travail ][Dommage!]");
  376.       close_gem();
  377.       exit(0);
  378.    }
  379.    /*****   Ouverture de la fenètre de travail   *****/
  380.    win.x=20;
  381.    win.y=20;
  382.    win.l=200;
  383.    win.h=200;
  384.    sprintf(temp,"Traceur de surface");
  385.    wind_set(win.handle,2,temp,0,0);
  386.    wind_open(win.handle,win.x,win.y,win.l,win.h);
  387.    /*****   Gestion des événements   *****/
  388.    while(1)
  389.    {
  390.       evnt_mesag(message);
  391.       switch(message[0])
  392.       {
  393.          case 10 :
  394.             mn_selected();
  395.             break;
  396.          case 20 :
  397.                  if(no_redraw==0)
  398.                      sys_redraw();
  399.                  else
  400.                      no_redraw=0;
  401.                     break;
  402.          case 21 :
  403.             wm_topped();
  404.             break;
  405.          case 22 :
  406.             wm_closed();
  407.             break;
  408.          case 23 :
  409.             wm_fulled();
  410.             break;
  411.          case 24 :
  412.             wm_arrowed();
  413.             break;
  414.          case 25 :
  415.             wm_hslide();
  416.             break;
  417.          case 26 :
  418.             wm_vslide();
  419.             break;
  420.          case 27 :
  421.             wm_sized();
  422.             break;
  423.          case 28 :
  424.             wm_moved();
  425.             break;
  426.       }
  427.    }
  428. }
  429.  
  430.  
  431. void mn_selected()
  432. {
  433.     switch(message[4])
  434.     {
  435.         case MINFO :
  436.         rsrc_gaddr(0,BOXINFO,&adr_info);
  437.         show_dialog(adr_info);
  438.             break;
  439.         case MQUIT :
  440.             wm_closed();
  441.             break;
  442.         case PAL1 :
  443.             menu_icheck(adr_menu,cas2,0);
  444.             cas2=PAL1;
  445.             menu_icheck(adr_menu,cas2,1);
  446.             wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  447.             clip_on(depx,depy,larg,haut);
  448.             hidem();  
  449.             wm_redraw();
  450.             showm();
  451.             clip_off();
  452.             break;
  453.         case PAL2 :
  454.             menu_icheck(adr_menu,cas2,0);
  455.             cas2=PAL2;
  456.             menu_icheck(adr_menu,cas2,1);
  457.             wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  458.             clip_on(depx,depy,larg,haut);
  459.             hidem();  
  460.             wm_redraw();
  461.             showm();
  462.             clip_off();
  463.             break;
  464.         case ANG :
  465.             rsrc_gaddr(0,DANGLE,&adr_angle);
  466.         show_angle();
  467.         wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  468.             clip_on(depx,depy,larg,haut);
  469.             hidem();  
  470.             wm_redraw();
  471.             showm();
  472.             clip_off();
  473.             break;
  474.         case AXES :
  475.             axes^=1;
  476.             menu_icheck(adr_menu,AXES,axes);
  477.             wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  478.             clip_on(depx,depy,larg,haut);
  479.             hidem();  
  480.             wm_redraw();
  481.             showm();
  482.             clip_off();
  483.             break;
  484.         case Z11 :
  485.             menu_icheck(adr_menu,cas,0);
  486.             cas=message[4];
  487.             menu_icheck(adr_menu,cas,1);
  488.             
  489.         show_acqui();
  490.         
  491.         wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  492.             clip_on(depx,depy,larg,haut);
  493.             hidem();  
  494.             wm_redraw();
  495.             showm();
  496.             clip_off();
  497.             break;
  498.         default :
  499.             menu_icheck(adr_menu,cas,0);
  500.             cas=message[4];
  501.             menu_icheck(adr_menu,cas,1);
  502.             wind_calc(1,CLOSER | MOVER | NAME | SIZER | FULLER,win.x,win.y,win.l,win.h,&depx,&depy,&larg,&haut);
  503.             clip_on(depx,depy,larg,haut);
  504.             hidem();  
  505.             wm_redraw();
  506.             showm();
  507.             clip_off();
  508.             break;
  509.     }
  510.   menu_tnormal(adr_menu,message[3],1);        
  511. }
  512.  
  513. int intersect(int x1,int y1,int w1,int h1,int x2,int y2,int w2,int h2)
  514. {
  515.     int aa,bb,cc,dd;
  516.     aa=(x2 > x1) ? x2 : x1;
  517.     bb=(y2 > y1) ? y2 : y1;
  518.     cc=(x2+w2 < x1+w1) ? x2+w2 : x1+w1;
  519.     dd=(y2+h2 < y1+h1) ? y2+h2 : y1+h1;
  520.     clip_on(aa,bb,cc-aa,dd-bb);
  521.     return(cc > aa && dd > bb);
  522. }
  523.  
  524. void sys_redraw()
  525. {
  526.     int xx,yy,ww,hh,rx,ry,rw,rh;
  527.     
  528.     wind_update(1);
  529.   xx=message[4];
  530.   yy=message[5];
  531.   ww=message[6];
  532.   hh=message[7];
  533.   
  534.   wind_get(win.handle,11,&rx,&ry,&rw,&rh);
  535.     hidem();
  536.     while(rw!=0)
  537.     {
  538.         if(intersect(xx,yy,ww,hh,rx,ry,rw,rh))
  539.           wm_redraw();
  540.       wind_get(win.handle,12,&rx,&ry,&rw,&rh);
  541.   }
  542.     showm();
  543.     clip_off();
  544.   wind_update(0);          
  545. }
  546.  
  547. void wm_topped()
  548. {
  549.     wind_set(win.handle,10,0,0,0,0);
  550. }
  551. void wm_closed()
  552. {
  553.    wind_close(win.handle);
  554.    close_gem();
  555.    exit(0);
  556. }
  557. void wm_fulled()
  558. {
  559.     win.x=1;
  560.     win.y=20;
  561.   win.l=win.fullx;
  562.   win.h=win.fully-20;
  563.   wind_set(win.handle,5,win.x,win.y,win.l,win.h);
  564. }
  565. void wm_arrowed()
  566. {
  567.  
  568. }
  569. void wm_hslide()
  570. {
  571.  
  572. }
  573. void wm_vslide()
  574. {
  575.  
  576. }
  577. void wm_sized()
  578. {
  579.      int flag=1;
  580.      if(message[6]>win.l || message[7]>win.h) flag=0;
  581.    win.l=message[6];
  582.    if(win.l<50)
  583.       win.l=50;
  584.    win.h=message[7];
  585.    if(win.h<50)
  586.       win.h=50;
  587.    wind_set(win.handle,5,win.x,win.y,win.l,win.h);
  588.    if(flag) sys_redraw();
  589. }
  590.  
  591. void wm_moved()
  592. {
  593.    wind_set(win.handle,5,message[4],message[5],win.l,win.h);
  594.    win.x=message[4];
  595.    win.y=message[5];
  596. }
  597.  
  598. void show_dialog(OBJECT *arbre)
  599. {
  600.     int tx,ty,tw,th;
  601.     form_center(arbre,&tx,&ty,&tw,&th);
  602.     form_dial(0,tx,ty,tw,th,tx,ty,tw,th);
  603.     form_dial(1,tx,ty,1,1,tx,ty,tw,th);
  604.     objc_draw(arbre,0,20,tx,ty,tw,th);
  605.     form_do(arbre,-1);
  606.     form_dial(2,tx,ty,1,1,tx,ty,tw,th);
  607.     form_dial(3,tx,ty,tw,th,tx,ty,tw,th);
  608.     arbre[BOXOK].ob_state &=-2;
  609. }
  610.  
  611. void show_acqui()
  612. {
  613.     char txt[50];
  614.     char file[14];
  615.     int but;
  616.     TEDINFO *ted;
  617.     int tx,ty,tw,th;
  618.     ted=(TEDINFO *)adr_acqui[ACQUIEDI].ob_spec.tedinfo;
  619.     strcpy(ted->te_ptext,eq);
  620.     acqui:
  621.     form_center(adr_acqui,&tx,&ty,&tw,&th);
  622.     form_dial(0,tx,ty,tw,th,tx,ty,tw,th);
  623.     form_dial(1,tx,ty,1,1,tx,ty,tw,th);
  624.     objc_draw(adr_acqui,0,20,tx,ty,tw,th);
  625.     form_do(adr_acqui,ACQUIEDI);
  626.     form_dial(2,tx,ty,1,1,tx,ty,tw,th);
  627.     form_dial(3,tx,ty,tw,th,tx,ty,tw,th);
  628.     if(intersect(win.x,win.y,win.l,win.h,tx,ty,tw,th) )
  629.     {
  630.         no_redraw=1;
  631.   }
  632.   clip_off();
  633.     if(adr_acqui[ACQUIOK].ob_state &0x1)
  634.     {
  635.       adr_acqui[ACQUIOK].ob_state &=0xfe;
  636.         ted=(TEDINFO *)adr_acqui[ACQUIEDI].ob_spec.tedinfo;
  637.         strcpy(eq,ted->te_ptext);
  638.     }
  639.     if(adr_acqui[ACQUIANU].ob_state &0x1)
  640.     {
  641.         adr_acqui[ACQUIANU].ob_state &=0xfe;
  642.     }
  643.     file[0]=0;
  644.     if(adr_acqui[ACQUISAV].ob_state &0x1)
  645.     {
  646.         adr_acqui[ACQUISAV].ob_state &=0xfe;
  647.         ted=(TEDINFO *)adr_acqui[ACQUIEDI].ob_spec.tedinfo;
  648.         Dgetpath(txt,0);
  649.         strcat(txt,"\\*.S3D");
  650.         fsel_input(txt,file,&but);
  651.         if(strchr(file,'.'))
  652.         {
  653.             strcpy(strchr(file,'.'),".s3d");
  654.         }
  655.         else
  656.         {
  657.             strcat(file,".s3d");
  658.         }
  659.         strcpy(strchr(txt,'*'),file);
  660.         if(but)
  661.         { 
  662.             but=creat(txt);
  663.             write(but,&R,sizeof(int));
  664.             write(but,&H,sizeof(int));
  665.             write(but,ted->te_ptext,strlen(ted->te_ptext)+1);
  666.             close(but);
  667.         }
  668.         goto acqui;
  669.     }
  670.     if(adr_acqui[ACQUIOUV].ob_state &0x1)
  671.     {
  672.         adr_acqui[ACQUIOUV].ob_state &=0xfe;
  673.         ted=(TEDINFO *)adr_acqui[ACQUIEDI].ob_spec.tedinfo;
  674.         Dgetpath(txt,0);
  675.         strcat(txt,"\\*.S3D");
  676.         fsel_input(txt,file,&but);
  677.         strcpy(strchr(txt,'*'),file);
  678.         if(but)
  679.         {
  680.             but=open(txt,O_RDONLY);
  681.             read(but,&R,sizeof(int));
  682.             read(but,&H,sizeof(int));
  683.             read(but,ted->te_ptext,50);
  684.             close(but);
  685.         }
  686.         goto acqui;
  687.     }
  688. }
  689.  
  690. void show_angle()
  691. {
  692.     TEDINFO *ted;
  693.     int tx,ty,tw,th;
  694.     ted=(TEDINFO *)adr_angle[AROTA].ob_spec.tedinfo;
  695.     if(R<0)
  696.         sprintf(ted->te_ptext,"%d",R);
  697.     else
  698.         sprintf(ted->te_ptext,"+%d",R);
  699.     ted=(TEDINFO *)adr_angle[AHAUT].ob_spec.tedinfo;
  700.     if(H<0)
  701.         sprintf(ted->te_ptext,"%d",H);
  702.     else
  703.         sprintf(ted->te_ptext,"+%d",H);
  704.  
  705.     
  706.     form_center(adr_angle,&tx,&ty,&tw,&th);
  707.     form_dial(0,tx,ty,tw,th,tx,ty,tw,th);
  708.     form_dial(1,tx,ty,1,1,tx,ty,tw,th);
  709.     objc_draw(adr_angle,0,20,tx,ty,tw,th);
  710.     form_do(adr_angle,AROTA);
  711.     form_dial(2,tx,ty,1,1,tx,ty,tw,th);
  712.     form_dial(3,tx,ty,tw,th,tx,ty,tw,th);
  713.     if(intersect(win.x,win.y,win.l,win.h,tx,ty,tw,th))
  714.         no_redraw=1;
  715.  
  716.     if(adr_angle[DAO].ob_state &0x1)
  717.     {
  718.         adr_angle[DAO].ob_state &=0xfe;
  719.         ted=(TEDINFO *)adr_angle[AROTA].ob_spec.tedinfo;
  720.         R=atoi(ted->te_ptext);
  721.         ted=(TEDINFO *)adr_angle[AHAUT].ob_spec.tedinfo;
  722.         H=atoi(ted->te_ptext);
  723.     }
  724.     else
  725.         adr_angle[DAA].ob_state &=0xfe;
  726. }